﻿package fr.babos.core.data.remote 
{
	/**
	 * Les imports
	 */
	import flash.events.ErrorEvent;
	import flash.events.Event;
	import flash.events.IOErrorEvent;
	import flash.events.SecurityErrorEvent;
	import flash.net.URLLoader;
	import flash.net.URLRequest;
	import fr.babos.core.data.remote.ADataRemote;
	import fr.babos.core.data.remote.IDataRemote;
	import fr.babos.core.roles.IDisposable;
	
	/**
	 * ...
	 * @author ZoulouX
	 */
	public class XMLRemote extends ADataRemote implements IDataRemote, IDisposable
	{
		/**
		 * Le constructeur
		 */
		public function XMLRemote ()
		{
			
		}
		
		/**
		 * Appeler un service XML.
		 * @param	pCommand : Le nom du fichier XML ou l'URI du service XML
		 * @param	pOptions : Les options
		 * @param	... rest : 
		 */
		override public function call (pCommand:String, pOptions:Object, ... rest):RemotingCall
		{
			// Passer à l'id suivant
			_callId ++;
			
			// Créer l'appel
			var caller:RemotingCall = new RemotingCall(_callId, pCommand, null, pOptions);
			
			// Le delegate vers la réussite
			function successDelegate (event:Event):void
			{
				remoteSuccessHandler(event, caller);
			}
			
			// Le delegate vers l'échec
			function errorDelegate (event:ErrorEvent):void
			{
				remoteErrorHandler(event, caller);
			}
			
			// Créer la routine
			function routine ():void
			{
				// Créer le loader et charger
				var loader:URLLoader = new URLLoader(new URLRequest(pCommand));
				
				// Ecouter les erreurs (référence faible car c'est un delegate)
				loader.addEventListener(IOErrorEvent.IO_ERROR, 				remoteErrorHandler, false, 0, true);
				loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, 	remoteErrorHandler, false, 0, true);
				
				// Ecouter la réussite (référence faible car c'est un delegate)
				loader.addEventListener(Event.COMPLETE, 					remoteSuccessHandler, false, 0, true);
			}
			
			// Spécifier la routine
			caller.routine = routine;
			
			// Ajouter à la pile
			_calls.push(caller);
			
			// Effectuer cet appel sauf si c'est spécifier dans les options
			if (pOptions == null || pOptions["immediateCall"] == null || pOptions["immediateCall"] == true)
				caller.execute();
			
			// Retourner l'appel
			return caller;
		}
		
		/**
		 * Un appel à été réussi
		 * @param	event
		 */
		protected function remoteSuccessHandler (event:Event, pCaller:RemotingCall):void 
		{
			
		}
		
		/**
		 * Un appel à échoué
		 * @param	event
		 */
		protected function remoteErrorHandler (event:ErrorEvent, pCaller:RemotingCall):void 
		{
			
		}
		
		/**
		 * Effacer
		 */
		override public function dispose ():void
		{
			
		}
	}
}